TrackBy with *ngFor என்றால் என்ன?
ஆங்குலர் பட்டியல் உருப்படிகளை எவ்வாறு அடையாளம் காண்கிறது என்பதை வரையறுக்கிறது.
உருப்படிகள் நகர்த்தப்படும்போது, செருகப்படும்போது அல்லது அகற்றப்படும்போது DOM முனைகளை மீண்டும் பயன்படுத்துவதை இயலுமைப்படுத்துகிறது.
பொதுவாக ஒவ்வொரு உருப்படிக்கும் ஒரு தனிப்பட்ட ID ஐ திருப்பி அனுப்புகிறது.
TrackBy எப்போது பயன்படுத்த வேண்டும்
- அடிக்கடி மறுசீரமைக்கப்படும், செருகப்படும் அல்லது அகற்றப்படும் பட்டியல்கள்
- தேவையற்ற மறு-வழங்கலைத் தவிர்ப்பதற்கும் செயல்திறனை மேம்படுத்துவதற்கும்
- உருப்படிகள் நிலையான, தனிப்பட்ட அடையாளங்காட்டிகளைக் கொண்டிருக்கும் போது
Performance Tip
trackBy இல்லாமல், ஆங்குலர் ஒவ்வொரு மாற்றத்திலும் முழு DOM மரத்தையும் மறுவழங்க வேண்டியிருக்கும். trackBy உடன், DOM முனைகள் தேவைப்படும்போது மீண்டும் பயன்படுத்தப்படும்.
TrackBy எவ்வாறு செயல்படுகிறது
Without trackBy
<li *ngFor="let item of items">
{{ item.name }}
</li>
சிக்கல்: ஒவ்வொரு மாற்றத்திலும் முழு பட்டியலையும் ஆங்குலர் மறுவழங்குகிறது
செயல்திறன்: மோசமானது
With trackBy
<li *ngFor="let item of items;
trackBy: trackById">
{{ item.name }}
</li>
நன்மை: ஆங்குலர் DOM முனைகளை மீண்டும் பயன்படுத்துகிறது
செயல்திறன்: சிறந்தது
Important Warning
தொடர்புடைய பைண்டிங்குகள் மற்றும் சங்கிலி விளைவுகளுடன் பெரிய பட்டியல்களுக்கு trackBy இல்லாமல், கடுமையான செயல்திறன் சிக்கல்கள் ஏற்படலாம்.
Example
Complete Angular Example
import { bootstrapApplication } from '@angular/platform-browser';
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
// Define Item type
type Item = {
id: number;
name: string
};
@Component({
selector: 'app-root',
standalone: true,
imports: [CommonModule],
template: `
<button (click)="shuffle()">Shuffle Items</button>
<ul>
<li *ngFor="let it of items; trackBy: trackById">
{{ it.id }} - {{ it.name }}
</li>
</ul>
`
})
export class App {
// Initial items array
items: Item[] = [
{ id: 1, name: 'Alpha' },
{ id: 2, name: 'Beta' },
{ id: 3, name: 'Gamma' }
];
// Shuffle method to reorder items
shuffle() {
// Reverse the array to demonstrate trackBy benefits
this.items = [...this.items].reverse();
}
// TrackBy function - identifies each item uniquely
trackById(_i: number, it: Item) {
return it.id;
}
}
bootstrapApplication(App);
Example Explained
*ngFor ... trackBy: trackById: பட்டியல் வரிசை மாறும்போது ஆங்குலர் DOM முனைகளை மீண்டும் பயன்படுத்தக்கூடிய வகையில் ஒவ்வொரு உருப்படிக்கும் நிலையான அடையாளத்தைக் கொடுக்க trackById ஐப் பயன்படுத்துகிறது.
trackById(index, item): ஒரு உருப்படிக்கான தனிப்பட்ட விசையைத் திருப்பி அனுப்புகிறது. இங்கே, குறியீட்டைப் பொருட்படுத்தாமல் item.id ஐத் திருப்பி அனுப்புகிறது.
shuffle(): trackBy உடன், ஆங்குலர் இருக்கும் DOM முனைகளை அழிப்பதற்கும் மீண்டும் உருவாக்குவதற்கும் பதிலாக நகர்த்துகிறது என்பதை நிரூபிக்க வரிசையை மாற்றுகிறது.
Visual Demonstration
Without trackBy
DOM முனைகள் அழிக்கப்பட்டு மீண்டும் உருவாக்கப்படுகின்றன
↓ Shuffle ↓
6 DOM செயல்பாடுகள்
With trackBy
DOM முனைகள் மீண்டும் பயன்படுத்தப்படுகின்றன
↓ Shuffle ↓
3 DOM செயல்பாடுகள்
Common TrackBy Patterns
Using ID Field
trackById(index, item) {
return item.id;
}
மிகவும் பொதுவான முறை
Using Unique Key
trackByKey(index, item) {
return item.uniqueKey;
}
மாற்று தனிப்பட்ட புலத்திற்கு
Using Index (Caution)
trackByIndex(index, item) {
return index;
}
இறுதி முயற்சியாக மட்டுமே - தரவு மாறினால் சிக்கல்கள்
Index as TrackBy Warning
குறியீட்டை trackBy செயல்பாடாகப் பயன்படுத்த வேண்டாம், ஏனெனில்:
- உருப்படிகள் சேர்க்கப்படும்போது அல்லது அகற்றப்படும்போது குறியீடுகள் மாறுகின்றன
- தவறான DOM மறுபயன்பாட்டிற்கு வழிவகுக்கும்
- தரவு பைண்டிங் சிக்கல்களை ஏற்படுத்தும்
Exercise
பட்டியல் வழங்கலுடன் trackBy பயன்படுத்துவதன் நன்மை என்ன?
பட்டியல் வழங்கலுடன் trackBy பயன்படுத்துவதன் நன்மை என்ன?
Best Practices for TrackBy
Always Use trackBy for Large Lists
50+ உருப்படிகள் கொண்ட எந்தப் பட்டியலுக்கும் trackBy ஐ எப்போதும் பயன்படுத்தவும்
Use Stable Unique Identifiers
உருப்படி வாழ்நாள் முழுவதும் மாறாத தனிப்பட்ட அடையாளங்காட்டிகளைப் பயன்படுத்தவும்
Never Use Random Values
Math.random() அல்லது Date.now() போன்ற சீரற்ற மதிப்புகளை trackBy செயல்பாடாகப் பயன்படுத்த வேண்டாம்
Performance Checklist
- ✅ பெரிய பட்டியல்களுக்கு எப்போதும் trackBy ஐப் பயன்படுத்தவும்
- ✅ உருப்படி வாழ்நாள் முழுவதும் நிலையான ID புலங்களைப் பயன்படுத்தவும்
- ✅ trackBy செயல்பாடு எளிமையாகவும் வேகமாகவும் இருக்க வேண்டும்
- ✅ பட்டியல் தரவு மாறும்போது குறியீட்டைப் பயன்படுத்துவதைத் தவிர்க்கவும்